Course: Core Java Training
Topic: Understanding public, private, protected, and Default Access
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy
Access modifiers are keywords in Java that control the visibility and accessibility of classes, variables, methods, constructors, and nested classes. They help developers decide which parts of a program can be accessed by other classes and which parts should remain hidden.
Access control is an important part of object-oriented programming because it supports encapsulation, protects internal data, reduces unwanted dependencies, and makes applications easier to maintain.
Java provides four common access levels for class members: public, private, protected, and default (package-private). Each level defines a different boundary for accessing a member.
For example, a bank account's balance should generally not be modified directly by every class in an application. A private field and public methods such as deposit() and withdraw() can control how the balance changes.
Java access levels determine how widely a member can be accessed. From the most restrictive to the most accessible, the general order is private, default, protected, and public, although protected access has special rules for subclasses in different packages.
| Access Level | Keyword | Accessibility |
|---|---|---|
| Private | private |
Only within the declaring top-level class's body, including its nested code where Java permits access. |
| Default / Package-private | No keyword | Within the same package. |
| Protected | protected |
Within the same package and through the applicable subclass access rules outside the package. |
| Public | public |
Wherever the declaring type itself is accessible. |
The public access modifier provides the widest accessibility. A public class or member can be accessed from other classes and packages, provided the declaring type and any other required access conditions allow it.
public class Student {
public String name = "Rahul";
public void displayName() {
System.out.println("Student Name: " + name);
}
}The name field and displayName() method are public. Another accessible class can use them through a Student object.
public class Main {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.name);
student.displayName();
}
}Output:
Rahul
Student Name: RahulAvoid making every field public. Public fields can allow other classes to change an object's state without validation.
The private access modifier restricts access to the declaring top-level class. Other unrelated classes cannot directly access that private member, even if they are in the same package.
Private access is commonly used to hide implementation details and protect an object's internal state.
public class Employee {
private double salary = 45000;
public void displaySalary() {
System.out.println("Salary: " + salary);
}
}The salary field is private. It can be accessed directly within the Employee class, but unrelated classes cannot access it directly.
public class Main {
public static void main(String[] args) {
Employee employee = new Employee();
// Compile-time error:
// System.out.println(employee.salary);
employee.displaySalary();
}
}Output:
Salary: 45000.0The direct field access is commented out because it would cause a compilation error. The public method provides an accessible way to display the salary.
A getter reads a field's value, while a setter updates it. Setters can validate data before making a change.
public class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
if (initialBalance < 0) {
throw new IllegalArgumentException(
"Initial balance cannot be negative"
);
}
balance = initialBalance;
}
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
}
public class Main {
public static void main(String[] args) {
BankAccount account = new BankAccount(1000);
account.deposit(500);
System.out.println("Balance: " + account.getBalance());
}
}Output:
Balance: 1500.0The private field prevents arbitrary direct changes from unrelated classes. The public methods define how the balance can be read and updated.
In Java, default access means that no explicit access modifier is written. This is also called package-private access. A member with default access can be used by classes in the same package but not by unrelated classes in other packages.
Default access is not represented by a keyword named default in an ordinary class field or method declaration. Writing default before an ordinary class method does not mean package-private access; the keyword has a different role for interface methods.
class Calculator {
int add(int a, int b) {
return a + b;
}
}The Calculator class and its add() method have default access. Classes in the same package can access them.
class Main {
public static void main(String[] args) {
Calculator calculator = new Calculator();
int result = calculator.add(10, 20);
System.out.println("Sum: " + result);
}
}Output:
Sum: 30This example works when both classes are in the same package. If Main is placed in another package, it cannot directly access the package-private Calculator class or its members.
The protected access modifier allows access within the same package and also provides access to subclasses located in other packages, subject to Java's protected-access rules.
It is often useful when a base class provides behavior or state intended for specialized subclasses.
class Animal {
protected void makeSound() {
System.out.println("Animal makes a sound.");
}
}
class Dog extends Animal {
public void bark() {
makeSound();
System.out.println("Dog barks.");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.bark();
}
}Output:
Animal makes a sound.
Dog barks.The Dog class inherits from Animal and can call the protected method as part of its subclass behavior.
When a subclass is in another package, protected access is more restricted than simply allowing access through any object. The subclass can access the inherited protected member through its own inheritance context, but ordinary code cannot freely access that member through any arbitrary superclass instance.
For example, a subclass can call an inherited protected method with makeSound() from one of its instance methods. However, code in an unrelated class in another package cannot call that protected method directly.
| Access Level | Same Class | Same Package | Subclass in Another Package | Unrelated Class in Another Package |
|---|---|---|---|---|
private |
Yes | No direct access | No direct access | No |
| Default (no modifier) | Yes | Yes | No | No |
protected |
Yes | Yes | Yes, subject to subclass access rules | No |
public |
Yes | Yes | Yes, if the declaring type is accessible | Yes, if the declaring type is accessible |
Important: The table describes access to members. Actual accessibility also depends on whether the declaring class and its enclosing types are themselves accessible.
Access rules for top-level classes differ from the rules for class members. A top-level class or interface can be declared public or left without a modifier, making it package-private.
A top-level class cannot be declared private or protected. Those access levels can be used for nested classes, where permitted.
package college;
public class Student {
public void display() {
System.out.println("Student class is accessible.");
}
}Other packages can access the public Student class if the package is available and the class is accessible in the application or module.
package college;
class Teacher {
void teach() {
System.out.println("Teacher is teaching.");
}
}The Teacher class can be accessed by other classes in the college package, but it cannot be directly imported and used from an unrelated package.
Fields store an object's state or class-level data. Choosing an appropriate access level helps prevent accidental changes and supports encapsulation.
public class Product {
public String name = "Laptop";
private double price = 55000;
protected int stock = 10;
String category = "Electronics";
public double getPrice() {
return price;
}
}In this example:
name is public and can be accessed wherever the class is accessible.price is private and can be accessed directly only within Product.stock is protected and follows package and subclass access rules.category has default access and is accessible within its package.For most application fields, private access is a good starting point. Public methods can expose only the operations that other classes need.
Methods define the behavior of a class. Their access modifiers determine which code can call them.
public class UserService {
public void registerUser() {
validateUser();
System.out.println("User registered.");
}
private void validateUser() {
System.out.println("Validating user...");
}
protected void logActivity() {
System.out.println("Activity logged.");
}
void resetCache() {
System.out.println("Cache reset.");
}
}Here, registerUser() is public, validateUser() is private, logActivity() is protected, and resetCache() has default access.
Output when registerUser() is called:
Validating user...
User registered.The public method can call the private helper because both belong to the same class. Other classes can call the public method without needing direct access to the validation logic.
Constructors initialize objects. Their access levels determine where instances can be created directly.
public class Utility {
private Utility() {
// Prevent direct object creation.
}
public static int square(int number) {
return number * number;
}
}
public class Main {
public static void main(String[] args) {
System.out.println(Utility.square(5));
}
}Output:
25The private constructor prevents other classes from creating a Utility object directly. The public static method can be called without creating an object.
Encapsulation means combining data and related methods within a class while controlling access to the object's internal state. Access modifiers are important tools for implementing encapsulation.
A common approach is to keep fields private and expose public methods that validate or manage changes.
public class Student {
private int marks;
public void setMarks(int marks) {
if (marks >= 0 && marks <= 100) {
this.marks = marks;
} else {
System.out.println("Invalid marks.");
}
}
public int getMarks() {
return marks;
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.setMarks(85);
System.out.println("Marks: " + student.getMarks());
student.setMarks(150);
}
}Output:
Marks: 85
Invalid marks.The private marks field cannot be modified directly by unrelated classes. The setter ensures that only values within the allowed range are accepted.
Inheritance allows one class to extend another class. Access modifiers affect which inherited members a subclass can use.
public members are accessible to subclasses when the declaring type is accessible.protected members are accessible to subclasses, including those in another package under the protected-access rules.private members cannot be accessed directly by subclasses, although the superclass's accessible methods may provide controlled access to them.class Person {
protected String name = "Aarav";
protected void displayName() {
System.out.println("Name: " + name);
}
}
class Student extends Person {
public void showDetails() {
displayName();
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.showDetails();
}
}Output:
Name: AaravThe subclass can access the protected field and method through its inheritance relationship.
default keyword: Package-private access is created by omitting a modifier.Student class with a private field for marks and public getter and setter methods.Calculator class with a private helper method used by a public calculation method.Access modifiers control the visibility of classes and class members, helping define which parts of a program can access particular declarations.
Java provides four common access levels for members: public, protected, default (package-private), and private.
public allows access wherever the declaring type and other relevant access conditions permit it.
private restricts direct access to the declaring top-level class's body, including access allowed to its nested code.
Default or package-private access applies when no access modifier is specified. The member can be accessed within its package.
protected allows access within the same package and through subclass access rules outside the package.
No. A top-level class can be public or package-private. Private and protected access can be used for nested classes where permitted.
No. A subclass cannot directly access its superclass's private members, but it may use accessible superclass methods that operate on those members.
Default access is limited to the same package. Protected access also permits certain accesses from subclasses in other packages.
Private is a good default choice for fields because it protects internal state and allows controlled access through methods.
Yes. A private constructor restricts direct construction from outside the declaring class and is often used in utility classes or controlled object-creation patterns.
They help hide implementation details, control access to data, prevent invalid changes, and define a clear boundary between a class and its users.
public: accessible wherever the declaring type is accessible.private: direct access restricted to the declaring top-level class and permitted nested code.protected: accessible within the package and through subclass rules outside the package.Understanding public, private, protected, and default access is essential for writing secure, maintainable, and well-structured Java applications. Each access level serves a different purpose: public exposes functionality, private hides internal details, default supports package-level collaboration, and protected supports package access and inheritance.
By selecting access modifiers carefully, developers can implement encapsulation, reduce unwanted dependencies, and design classes with clear responsibilities. Practicing these concepts with multiple classes and packages will strengthen your Core Java and object-oriented programming skills.
Explore the Core Java Training Course to strengthen your understanding of Java fundamentals, object-oriented programming, and access control.
Register for a Course Demo to learn more about the training program.
Visit the JustAcademy website to explore additional courses and learning resources.
